Django URL-i marsruutimine: täiustatud mustrite sobitamise valdamine tugevate veebirakenduste jaoks

Django, kõrgetasemeline Pythoni veebiraamistik, lihtsustab keerukate veebirakenduste arendamist. Iga veebirakenduse kriitiline komponent on selle URL-i marsruutimise süsteem. Django URL-i dispetšer on uskumatult võimas, võimaldades teil määratleda puhtaid, loetavaid ja hallatavaid URL-i mustreid. See juhend süveneb Django URL-i marsruutimise täiustatud mustrite sobitamise tehnikatesse, võimaldades teil ehitada väga paindlikke ja tõhusaid veebirakendusi, mis sobivad ülemaailmsele vaatajaskonnale. Uurime regulaaravaldisi, URL-i parameetreid ja parimaid tavasid, et muuta teie marsruutimise süsteem nii tugevaks kui ka hõlpsasti mõistetavaks.

Django URL-i marsruutimise põhialuste mõistmine

Enne täiustatud mustrite sobitamisse sukeldumist kordame põhitõdesid. Django kasutab URL-i dispetšerit, mis kaardistab URL-i mustrid konkreetsetele vaadetele. Need vaated haldavad antud URL-i sisu loogikat ja renderdamist. URL-i mustrid on määratletud Pythoni failis nimega urls.py, mis asub tavaliselt teie Django rakenduse või projekti kataloogis.

Lihtne URL-i muster näeb välja selline:

            from django.urls import path
from . import views

urlpatterns = [
    path('artiklid/2003/', views.special_case_2003_view),
    path('artiklid/<int:year>/', views.year_archive),
    path('artiklid/<int:year>/<int:month>/', views.month_archive),
    path('artiklid/<int:year>/<int:month>/<slug:slug>/', views.article_detail),
]

            

              
                Copy
              
            
          

Selles näites:

• path() on funktsioon, mida kasutatakse URL-i mustri määratlemiseks.
• Esimene argument funktsioonile path() on URL-i muster ise, mis võib sisaldada sõnasõnalisi stringe või mustreid, kasutades nurksulgusid (<...>) URL-i osade jäädvustamiseks.
• Teine argument on vaatefunktsioon, mida kutsutakse, kui URL vastab mustrile.

Regulaaravaldised Django URL-i mustrites

Kuigi Django pakub sisseehitatud konvertereid (nagu <int:year> ja <slug:slug>), vajate sageli URL-i mustrite üle peenemat kontrolli. Siin tulevad sisse regulaaravaldised (regex). Regulaaravaldised võimaldavad teil määratleda keerukaid mustreid erinevate URL-i struktuuride sobitamiseks. Django funktsiooni re_path(), mis on imporditud moodulist django.urls, kasutatakse URL-i mustrite määratlemiseks regulaaravaldiste abil.

Siin on, kuidas saate kasutada re_path():

            from django.urls import re_path
from . import views

urlpatterns = [
    re_path(r'^artiklid/([0-9]{4})/$', views.year_archive),
    re_path(r'^artiklid/([0-9]{4})/([0-9]{2})/$', views.month_archive),
]

            

              
                Copy
              
            
          

Selles näites:

• re_path() võtab oma esimese argumendina vastu toore stringi (r''), mis sisaldab regulaaravaldist.
• ^ sobitab URL-i alguse.
• $ sobitab URL-i lõpu.
• ([0-9]{4}) sobitab täpselt neli numbrit ja jäädvustab need grupina. See jäädvustatud grupp edastatakse seejärel argumendina teie vaatefunktsioonile.
• Sulgud () kasutatakse regulaaravaldises jäädvustavate gruppide määratlemiseks. Need grupid edastatakse positsiooniliste argumentidena vaatele.

Kaaluge ülemaailmset e-kaubanduse saiti. Võite kasutada regulaaravaldist toote URL-ide sobitamiseks, võimaldades erinevaid nimetamiskonventsioone ja tootekoodide:

            re_path(r'^tooted/(?P<product_code>[A-Z]{3}-[0-9]{3})/(?P<product_name>[a-z-]+)/$', views.product_detail),

            

              
                Copy
              
            
          

Sel juhul vastaks URL /tooted/ABC-123/punane-vidin/ ja vaade product_detail saaks jäädvustatud grupid nimega 'product_code' ja 'product_name' märksõna argumentidena.

Nimetatud grupid regulaaravaldistes

Regulaaravaldistega töötamisel on sageli loetavam ja hallatavam kasutada nimetatud gruppe positsiooniliste argumentide asemel. Nimetatud grupid võimaldavad teil oma vaatefunktsioonides viidata jäädvustatud gruppidele nime järgi.

Nimetatud gruppide kasutamiseks kasutage oma regulaaravaldises süntaksit (?P<name>pattern):

            from django.urls import re_path
from . import views

urlpatterns = [
    re_path(r'^artiklid/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/$', views.month_archive),
]

            

              
                Copy
              
            
          

Selles näites saaks vaatefunktsioon month_archive jäädvustatud aasta ja kuu märksõna argumentidena: year=2023, month=12. See muudab vaatekoodi palju puhtamaks ja hõlpsamini mõistetavaks.

Sisseehitatud URL-i konverterid: mugav alternatiiv

Django pakub mitmesuguseid sisseehitatud URL-i konvertereid, mis võivad teie URL-i mustreid lihtsustada ja muuta need loetavamaks, eriti tavaliste juhtumite korral. Need konverterid on lihtsate juhtumite korral regulaaravaldistest lühemad.

Siin on mõned sisseehitatud konverterid:

• str: sobitab mis tahes mittetühja stringi (välja arvatud teepiiraja '/').
• int: sobitab ühe või mitu numbrit.
• slug: sobitab slug'i, mis on tavaliselt string, mis sisaldab tähti, numbreid, sidekriipse ja allkriipse.
• uuid: sobitab UUID-i (universaalselt unikaalne identifikaator).
• path: sobitab mis tahes mittetühja teestringi (sealhulgas teepiiraja '/').

Näide sisseehitatud konverterite kasutamisest:

            from django.urls import path
from . import views

urlpatterns = [
    path('blogi/postitus/<slug:post_slug>/', views.post_detail, name='post_detail'),
    path('tooted/<int:product_id>/', views.product_detail, name='product_detail'),
]

            

              
                Copy
              
            
          

Sisseehitatud konverterite kasutamine on üldiselt eelistatav, kui need vastavad teie vajadustele, kuna neid on lihtsam lugeda ja hallata.

URL-i mustrite järjekord ja ülimuslikkus

Teie URL-i mustrite järjekord failis urls.py on ülioluline. Django töötleb mustreid määratlemise järjekorras, peatudes esimese vaste juures. Kui teil on kattuvad mustrid, määrab järjekord, milline vaade kutsutakse. Näiteks kaaluge neid mustreid:

            urlpatterns = [
    path('artiklid/loo/', views.article_create),
    path('artiklid/<int:article_id>/', views.article_detail),
]

            

              
                Copy
              
            
          

Kui artikli loomise muster (/artiklid/loo/) asetatakse pärast konkreetse artikli kuvamise mustrit (/artiklid/<int:article_id>/), võib <int:article_id> muster valesti sobitada URL-i 'loo', mis viib ootamatu käitumiseni. Asetage alati täpsemad mustrid *enne* üldisemaid mustreid.

URL-i nimeruumid ja pöördlahendus

Kui teie Django projekt kasvab, võivad teie URL-i mustrid muutuda keerukaks. URL-i nimeruumid ja pöördlahendus aitavad teie URL-e hallata ja parandavad koodi hallatavust.

URL-i nimeruumid

URL-i nimeruumid aitavad vältida nimetamiskonflikte, kui teil on mitu sarnaste URL-i mustritega rakendust. Need pakuvad viisi oma URL-i mustrite "ulatusse" seadmiseks. Nimeruumide kasutamiseks ümbritsete oma rakenduse URL-i mustrid URLconf-iga (tavaliselt projekti urls.py failis):

            from django.urls import include, path

urlpatterns = [
    path('blogi/', include(('blogi.urls', 'blogi'), namespace='blogi')),
    path('pood/', include(('pood.urls', 'pood'), namespace='pood')),
]

            

              
                Copy
              
            
          

Selles näites seatakse rakenduse 'blogi' URL-id nimeruumi 'blogi' alla ja rakenduse 'pood' URL-id nimeruumi 'pood' alla. See aitab vältida konflikte, kui mõlemal rakendusel on näiteks URL-i muster nimega 'detail'. Viitaksite blogi detailsele URL-ile, kasutades blogi:detail ja poe detailsele URL-ile, kasutades pood:detail, kui kasutate mallisilti {% url %} (vt allpool) või funktsiooni reverse() (ka allpool).

Pöördlahendus

Pöördlahendus on URL-ide genereerimise protsess vaate nime ja vajalike parameetrite põhjal. See on ülioluline teie URL-ide hallatavuse säilitamiseks. Kui muudate oma failis urls.py URL-i mustrit, ei pea te kõiki linke oma mallides või vaadetes värskendama; peate värskendama ainult URL-i mustrit. Django värskendab genereeritud URL-e automaatselt.

Pöördlahenduse kasutamiseks peate oma URL-i mustritele nime andma, kasutades argumenti name:

            from django.urls import path
from . import views

urlpatterns = [
    path('artiklid/<int:pk>/', views.article_detail, name='article_detail'),
]

            

              
                Copy
              
            
          

Oma mallides saate URL-ide genereerimiseks kasutada mallisilti {% url %}:

            <a href="{% url 'article_detail' pk=article.pk %}">Vaata artiklit</a>

            

              
                Copy
              
            
          

Oma vaadetes saate kasutada funktsiooni reverse() moodulist django.urls:

            from django.urls import reverse

def some_view(request, article_id):
    url = reverse('article_detail', args=[article_id])  # Kasutades positsioonilisi argumente
    # või
    url = reverse('article_detail', kwargs={'pk': article_id}) # Kasutades märksõna argumente
    # ...

            

              
                Copy
              
            
          

Pöördlahendus parandab oluliselt teie Django rakenduse hallatavust. Kaaluge mitmekeelset e-kaubanduse veebisaiti. Kui toote URL-i struktuur muutub sõltuvalt keelest või piirkonnast (nt keelekoodi lisamine), peate värskendama ainult URL-i mustreid, mitte lugematuid linke kogu oma veebisaidil.

Rahvusvahelistumise ja lokaliseerimise käsitlemine URL-i marsruutimises

Ülemaailmsele vaatajaskonnale mõeldud veebirakenduse loomisel on rahvusvahelistumine (i18n) ja lokaliseerimine (l10n) ülimalt olulised. Django pakub mõlema jaoks tugevat tuge. Teie URL-i marsruutimist saab kohandada erinevate keelte ja piirkondlike seadete toetamiseks.

Keele eesliited URL-ides

Üks levinud lähenemisviis on keelekoodi lisamine URL-i. Django funktsioon i18n_patterns() (moodulist django.conf.urls.i18n) lihtsustab seda. See lisab automaatselt teie URL-i mustritele kasutaja eelistatud keelekoodi. See nõuab, et teie seades MIDDLEWARE oleks aktiveeritud 'django.middleware.locale.LocaleMiddleware'.

            from django.conf.urls.i18n import i18n_patterns
from django.urls import include, path

urlpatterns = [
    path('admin/', admin.site.urls),
    path('kontod/', include('kontod.urls')),
]

urlpatterns += i18n_patterns(
    path('', include('minurakendus.urls')),
    # Lisage siia rohkem mustreid
    prefix_default_language=False,  # Seadke väärtuseks True, et lisada ka vaikimisi keele eesliide
)

            

              
                Copy
              
            
          

Selle konfiguratsiooni korral näevad URL-id välja nagu /et/… (eesti), /fr/… (prantsuse) jne. Django haldab keeleläbirääkimisi automaatselt kasutaja brauseri seadete või muude konfiguratsioonide põhjal. See võimaldab veebisaidil dünaamiliselt kuvada sisu kasutaja eelistatud keeles.

URL-i tõlkimine, kasutades gettext

Django tõlkeraamistik, kasutades gettext, võimaldab teil tõlkida tekstistringe oma URL-ides. Saate mähkida tekstistringid oma URL-i mustrites funktsiooniga gettext_lazy() moodulist django.utils.translation. See tagab, et URL-i muster tõlgitakse lehe renderdamisel sobivalt. Veenduge, et teie failis settings.py oleks seatud USE_I18N = True.

            from django.urls import path
from django.utils.translation import gettext_lazy as _
from . import views

urlpatterns = [
    path(_('umbes/'), views.about_view, name='about'),  # Näite tõlge
]

            

              
                Copy
              
            
          

Kui kasutaja eelistatud keel on näiteks prantsuse keel, tõlgitakse string _('umbes/') prantsuse keele ekvivalendiks (nt '/a-propos/'), tagades lokaliseeritud kasutuskogemuse. Pidage meeles, et käivitage tõlkefailide genereerimiseks python manage.py makemessages.

Piirkonnaspetsiifiliste andmete käsitlemine

Piirkonnaspetsiifiliste andmete, näiteks erinevate valuuta vormingute või kuupäevavormingute jaoks saate kasutada Pythonis moodulit `locale` ja konfigureerida oma mallid sobivate keelekoodidega, et need vastaksid lokaliseeritud vormingutele.

Täiustatud tehnikad ja kaalutlused

Kohandatud URL-i konverterid

Väga spetsiifiliste ja mittestandardsete URL-i mustrite jaoks saate luua kohandatud URL-i konvertereid. Need on klassid, mis määratlevad, kuidas teisendada URL-ist jäädvustatud string Pythoni objektiks ja kuidas teisendada see objekt tagasi URL-i mustristringiks. Kohandatud konverterid pakuvad kõrgeimat paindlikkust.

Siin on põhiline näide kohandatud konverterist, mis teisendab kuueteistkümnendsüsteemi värvikoodi värviobjektiks:

            # Teie rakenduse failis urls.py
from django.urls import register_converter

class HexColorConverter:
    regex = r'[0-9a-fA-F]{6}'

    def to_python(self, value):
        return value  # Või teisendage vajadusel värviobjektiks

    def to_url(self, value):
        return value.lower()  # Tagage URL-i jaoks järjepidev väiketäht

register_converter(HexColorConverter, 'hexcolor')

            

              
                Copy
              
            
          

Nüüd oma failis urls.py:

            from django.urls import path
from . import views

urlpatterns = [
    path('värvid/<hexcolor:color_code>/', views.color_detail, name='color_detail'),
]

            

              
                Copy
              
            
          

Vaade color_detail saab nüüd kuueteistkümnendsüsteemi värvikoodi stringina.

URL-i mustrite testimine

URL-i mustrite põhjalik testimine on ülioluline, et tagada nende ootuspärane toimimine. Django pakub testimisraamistikku, mis võimaldab teil kirjutada teste, mis kontrollivad, kas teie URL-id lahendatakse õigete vaadete jaoks õigete parameetritega. Kasutage Django testimisvahendeid ühiktestide ja integratsioonitestide kirjutamiseks, et valideerida oma marsruutimise loogika. See aitab vigu varakult tabada ja hoiab ära ootamatu käitumise.

Lihtsa testi näide:

            from django.test import Client, TestCase
from django.urls import reverse

class URLTests(TestCase):
    def test_article_detail_url(self):
        url = reverse('article_detail', kwargs={'pk': 123})
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200) # Või mõni muu sobiv vastus

            

              
                Copy
              
            
          

Turvakaalutlused

URL-i mustreid kavandades kaaluge turvamõjusid. Näiteks:

• Sisendi valideerimine: valideerige alati URL-i parameetritest saadav sisend, et vältida süstimisrünnakuid. Kasutage Django sisseehitatud mehhanisme, näiteks lubatud märkide piiratud komplekti või regulaaravaldiste kasutamist või sisseehitatud konverterite kasutamist.
• CSRF-kaitse: veenduge, et teil on lubatud CSRF-kaitse kõikide POST-päringute jaoks, mis andmeid muudavad.
• Kiiruse piiramine: rakendage kiiruse piiramine, et kaitsta teenusetõkestusrünnakute (DoS) eest.

Parimad tavad Django URL-i marsruutimiseks

Nende parimate tavade järgimine aitab teil luua hallatava ja skaleeritava Django rakenduse:

• Hoidke URL-id puhtad ja loetavad: püüdke URL-ide poole, mida on lihtne mõista ja mis kajastavad teie andmete ja rakenduse struktuuri.
• Kasutage tähenduslikke nimesid: kasutage oma URL-i mustrite ja vaatefunktsioonide jaoks selgeid ja kirjeldavaid nimesid.
• Kasutage sisseehitatud konvertereid: kasutage võimaluse korral Django sisseehitatud konvertereid, et hoida oma URL-i mustrid lühikesed.
• Kasutage nimeruume: korraldage oma URL-i mustrid nimeruumide abil, eriti kui töötate mitme rakendusega.
• Kasutage pöördlahendust: kasutage alati URL-ide genereerimiseks pöördlahendust (reverse() ja {% url %}).
• Kommenteerige oma koodi: lisage oma faili urls.py kommentaare, et selgitada keerukaid URL-i mustreid või kujundusvalikuid.
• Testige põhjalikult: kirjutage põhjalikke teste, et tagada oma URL-i mustrite ootuspärane toimimine.
• Järgige vähima üllatuse põhimõtet: kujundage oma URL-id nii, et need käituksid nii, nagu kasutajad ootaksid.
• Kaaluge SEO-d: optimeerige oma URL-id otsingumootorite jaoks. Kasutage oma URL-i teedes asjakohaseid märksõnu ja looge inimloetavaid URL-e.
• Dokumentatsioon: dokumenteerige oma URL-i struktuur ja mustrid põhjalikult, eriti väliste API-de jaoks. Kasutage tööriista nagu OpenAPI (Swagger), et aidata.

Näide: blogi ehitamine täiustatud marsruutimisega

Illustreerime neid kontseptsioone praktilise näitega lihtsa blogi ehitamisest. See näide kasutab sisseehitatud konverterite, nimetatud gruppide ja pöördlahenduse kombinatsiooni.

Esmalt määratlege oma mudelid (lihtsustatud selguse huvides):

            # models.py
from django.db import models
from django.utils.text import slugify

class Author(models.Model):
    name = models.CharField(max_length=200)

    def __str__(self):
        return self.name

class Category(models.Model):
    name = models.CharField(max_length=200, unique=True)
    slug = models.SlugField(max_length=200, unique=True, blank=True, null=True)

    def __str__(self):
        return self.name

    def save(self, *args, **kwargs):
        if not self.slug:
            self.slug = slugify(self.name)
        super().save(*args, **kwargs)

class Post(models.Model):
    title = models.CharField(max_length=200)
    slug = models.SlugField(max_length=200, unique=True, blank=True, null=True)
    content = models.TextField()
    author = models.ForeignKey(Author, on_delete=models.CASCADE)
    category = models.ForeignKey(Category, on_delete=models.SET_NULL, blank=True, null=True)
    published_date = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.title

    def save(self, *args, **kwargs):
        if not self.slug:
            self.slug = slugify(self.title)
        super().save(*args, **kwargs)


            

              
                Copy
              
            
          

Seejärel looge blogi rakenduse jaoks fail urls.py:

            # urls.py
from django.urls import path
from . import views

app_name = 'blogi'

urlpatterns = [
    path('', views.post_list, name='post_list'),
    path('postitus/<slug:slug>/', views.post_detail, name='post_detail'),
    path('kategooria/<slug:slug>/', views.category_detail, name='category_detail'),
    path('autor/<int:pk>/', views.author_detail, name='author_detail'),
]

            

              
                Copy
              
            
          

Nüüd määratlege vaated oma failis views.py:

            # views.py
from django.shortcuts import render, get_object_or_404
from .models import Post, Category, Author

def post_list(request):
    posts = Post.objects.all().order_by('-published_date')
    return render(request, 'blogi/post_list.html', {'posts': posts})

def post_detail(request, slug):
    post = get_object_or_404(Post, slug=slug)
    return render(request, 'blogi/post_detail.html', {'post': post})

def category_detail(request, slug):
    category = get_object_or_404(Category, slug=slug)
    posts = Post.objects.filter(category=category).order_by('-published_date')
    return render(request, 'blogi/category_detail.html', {'category': category, 'posts': posts})

def author_detail(request, pk):
    author = get_object_or_404(Author, pk=pk)
    posts = Post.objects.filter(author=author).order_by('-published_date')
    return render(request, 'blogi/author_detail.html', {'author': author, 'posts': posts})


            

              
                Copy
              
            
          

Selles näites kasutab iga URL-i muster kirjeldavat nime (nt post_detail, category_detail, author_detail) ja sisseehitatud konverterite kombinatsiooni (<slug:slug>, <int:pk>). Slug-konverterit kasutatakse postituse, kategooria ja autori vaadete jaoks, samas kui int-konverterit kasutatakse autori vaate jaoks.

Postituse detaillehele linkimiseks oma mallis:

            <a href="{% url 'blogi:post_detail' slug=post.slug %}">{{ post.title }}</a>

            

              
                Copy
              
            
          

Osa `blogi:post_detail` kasutab nimeruumi, mille deklareerisime peamises projekti URLconf-is (vt jaotist nimeruumide kohta), samas kui slug=post.slug pakub vajalikud parameetrid. See näide demonstreerib pöördlahenduse eeliseid. Kui postituste URL-i struktuur muutub, tuleb värskendada ainult URL-i mustreid ja mallilingid jäävad puutumata.

Järeldus: Django URL-i marsruutimise jõu rakendamine

Django URL-i marsruutimise süsteem on tugevate ja hallatavate veebirakenduste ehitamise põhiline aspekt. See juhend on käsitlenud täiustatud mustrite sobitamise põhiprintsiipe, sealhulgas regulaaravaldised, nimetatud grupid, sisseehitatud konverterid, nimeruumid, pöördlahendus ja rahvusvahelistumine. Neid tehnikaid valdades saate luua paindlikke, hästi struktureeritud ja hõlpsasti skaleeritavaid veebirakendusi, mis sobivad ülemaailmsele vaatajaskonnale.

Pidage alati meeles, et seate esikohale puhtad URL-id, õige nimetamise ja põhjaliku testimise, et tagada oma rakenduse hõlpsasti mõistetav, hallatav ja laiendatav. Siin omandatud oskuste ja teadmistega olete hästi varustatud keerukate Django rakenduste loomiseks, mis suudavad käsitleda mitmekesiseid URL-i struktuure ja toetada kasutajaid kogu maailmas. Pidev õppimine ja harjutamine on üliolulised Django võimsate URL-i marsruutimise võimaluste valdamiseks. Katsetage kohandatud konverteritega, lisage rahvusvahelistumise funktsioone ja looge tugevaid testkomplekte, et tagada oma projektide valmisolek ülemaailmse veebi väljakutseteks.